#!/usr/bin/env python
# -*- coding: utf-8 -*-

from flask import current_app
import re
import math
from collections import defaultdict
import heapq

class AIKnowledgeService:
    """简单的AI知识库服务，用于检索相关问题和历史解决方案"""
    
    def __init__(self):
        # 初始化服务
        self.initialized = False
        
    def initialize(self):
        # 在此初始化服务，实际项目中可能需要连接到真正的AI服务或知识库
        self.initialized = True
        return self.initialized
    
    def search_relevant_issues(self, query, issues, top_k=5):
        """
        根据查询内容搜索相关的问题
        参数:
            query: 搜索查询字符串
            issues: 问题列表
            top_k: 返回的最大结果数
        返回:
            相关问题列表，按相关性排序
        """
        if not self.initialized:
            self.initialize()
        
        # 简单的基于关键词匹配的搜索实现
        # 在实际项目中，这里可以替换为更复杂的NLP模型或向量搜索
        results = []
        query_words = self._extract_keywords(query)
        
        for issue in issues:
            # 计算问题与查询的相关性分数
            score = self._calculate_relevance_score(issue, query_words)
            if score > 0:
                # 使用优先队列来保持结果按分数排序
                heapq.heappush(results, (-score, issue))  # 使用负数因为Python的heapq是最小堆
        
        # 获取top_k个结果
        top_results = []
        for _ in range(min(top_k, len(results))):
            if results:
                score, issue = heapq.heappop(results)
                top_results.append((-score, issue))
        
        return top_results
    
    def suggest_solutions(self, issue, comments):
        """
        根据问题和评论内容，提供可能的解决方案建议
        参数:
            issue: 问题对象
            comments: 评论列表
        返回:
            解决方案建议列表
        """
        if not self.initialized:
            self.initialize()
        
        # 简单的解决方案建议实现
        # 在实际项目中，这里可以集成更复杂的AI模型来生成建议
        solutions = []
        
        # 从评论中提取可能的解决方案
        for comment in comments:
            solution = self._extract_potential_solution(issue, comment)
            if solution:
                solutions.append(solution)
        
        # 如果没有找到解决方案，提供通用建议
        if not solutions:
            solutions.append(self._generate_generic_solution(issue))
        
        return solutions
    
    def extract_key_insights(self, issue, comments):
        """
        从问题和评论中提取关键见解
        参数:
            issue: 问题对象
            comments: 评论列表
        返回:
            关键见解列表
        """
        insights = []
        
        # 提取问题的关键点
        issue_insights = self._extract_issue_key_points(issue)
        insights.extend(issue_insights)
        
        # 从评论中提取见解
        for comment in comments:
            comment_insights = self._extract_comment_insights(comment)
            insights.extend(comment_insights)
        
        # 去重并返回
        unique_insights = list({insight['text']: insight for insight in insights}.values())
        return unique_insights
    
    # 私有辅助方法
    def _extract_keywords(self, text):
        """从文本中提取关键词"""
        # 转小写
        text = text.lower()
        # 移除标点符号
        text = re.sub(r'[^\w\s]', ' ', text)
        # 分割成单词
        words = text.split()
        # 过滤停用词
        stop_words = set(['的', '了', '在', '是', '我', '有', '和', '就', '不', '人', '都', '一', '一个', '上', '也', '很', '到', '说', '要', '去', '你', '会', '着', '没有', '看', '好', '自己', '这'])
        keywords = [word for word in words if word not in stop_words and len(word) > 1]
        return keywords
    
    def _calculate_relevance_score(self, issue, query_words):
        """计算问题与查询的相关性分数"""
        if not query_words:
            return 0
        
        # 提取问题中的关键词
        issue_text = f"{issue.title} {issue.description}"
        issue_words = self._extract_keywords(issue_text)
        
        # 计算词频和逆文档频率（简化版）
        word_count = defaultdict(int)
        for word in issue_words:
            word_count[word] += 1
        
        # 计算匹配的查询词数量和权重
        score = 0
        for word in query_words:
            if word in word_count:
                # 标题中的匹配权重更高
                title_match = 2.0 if word in issue.title.lower() else 1.0
                score += word_count[word] * title_match
        
        # 归一化分数
        if score > 0:
            score = score / (len(query_words) * math.log(len(issue_words) + 1))
        
        return score
    
    def _extract_potential_solution(self, issue, comment):
        """从评论中提取潜在的解决方案"""
        # 简单的模式匹配，查找可能包含解决方案的评论
        solution_keywords = ['解决', '修复', '建议', '方法', '方案', '可以试试', '应该', '需要', '步骤']
        
        comment_text = comment.content.lower()
        for keyword in solution_keywords:
            if keyword in comment_text:
                # 提取包含关键词的句子
                sentences = re.split(r'[。！？\n]', comment_text)
                for sentence in sentences:
                    if keyword in sentence and len(sentence) > 10:
                        return {
                            'text': sentence,
                            'source': f'来自用户 {comment.user.username} 的评论',
                            'confidence': 0.7  # 简化的置信度评分
                        }
        
        return None
    
    def _generate_generic_solution(self, issue):
        """生成通用的解决方案建议"""
        # 根据问题类别提供不同的通用建议
        category = issue.category or ''
        
        if category == 'bug':
            solution = "建议检查相关错误日志，确认问题发生的具体条件和环境。尝试复现问题并逐步排除可能的原因。"
        elif category == 'feature':
            solution = "建议详细描述所需功能的使用场景、目标用户和预期效果，以便开发团队更好地理解需求。"
        elif category == 'question':
            solution = "建议查看相关文档或联系技术支持，提供更多上下文信息以便获得更准确的解答。"
        else:
            solution = "建议收集更多信息，明确问题的具体表现和影响范围，以便找到合适的解决方案。"
        
        return {
            'text': solution,
            'source': '系统建议',
            'confidence': 0.5
        }
    
    def _extract_issue_key_points(self, issue):
        """从问题中提取关键点"""
        insights = []
        
        # 提取问题类型
        if issue.category:
            insights.append({
                'text': f"问题类型：{issue.category}",
                'importance': 0.9
            })
        
        # 提取优先级
        if issue.priority:
            insights.append({
                'text': f"优先级：{issue.priority}",
                'importance': 0.8
            })
        
        # 提取主要关键词
        keywords = self._extract_keywords(f"{issue.title} {issue.description}")
        if keywords:
            # 获取最常见的3个关键词
            word_count = defaultdict(int)
            for word in keywords:
                word_count[word] += 1
            top_keywords = sorted(word_count.items(), key=lambda x: x[1], reverse=True)[:3]
            keywords_text = ', '.join([word for word, _ in top_keywords])
            insights.append({
                'text': f"主要关键词：{keywords_text}",
                'importance': 0.7
            })
        
        return insights
    
    def _extract_comment_insights(self, comment):
        """从评论中提取见解"""
        insights = []
        comment_text = comment.content
        
        # 检查是否包含解决方案
        if any(keyword in comment_text.lower() for keyword in ['解决', '修复', '方法']):
            insights.append({
                'text': f"可能的解决方案：{comment_text[:100]}...",
                'importance': 0.8,
                'source': f'用户 {comment.user.username}'
            })
        
        # 检查是否包含问题原因分析
        if any(keyword in comment_text.lower() for keyword in ['原因', '因为', '由于', '可能是']):
            insights.append({
                'text': f"问题分析：{comment_text[:100]}...",
                'importance': 0.7,
                'source': f'用户 {comment.user.username}'
            })
        
        return insights

# 创建服务实例
service = AIKnowledgeService()
service.initialize()

# 为了与原代码兼容，创建ai_knowledge_service别名
ai_knowledge_service = service